COMMENT ⊗   VALID 00002 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	(declare 
C00011 ENDMK
C⊗;
(declare 
 (fasload meter)
 (load "metint.lsp")
 (setq meter:count-only T))
(declare 
 (setq local-objects-of-interest 
       '((putprop "Putprops")
	 (get "Gets" get)
	 (pointergp "Gets" get 2)
	 (quotient "Quotients")
	 (oddp "Oddps")
	 (zerop "Zerops")
	 (pcoefp "Atoms" atom)
	 (pzerop "Signps" signp)
	 (cplus "Pluses" plus)(plus "Pluses" plus)
	 (ctimes "Times's" times)(times "Times's" times))))

(declare (special ans coef f inc i k qq ss v *x*
		    *alpha *a* *b* *chk *l *p q* u* *var *y*
		    r r2 r3 start res1 res2 res3))

(defmacro pointergp (x y) `(> (get ,x 'order)(get ,y 'order)))

(defmacro pcoefp (e) `(atom ,e))
(defmacro pzerop (x) `(signp e ,x))			;true for 0 or 0.0
(defmacro pzero () 0)
(defmacro cplus (x y) `(plus ,x ,y))
(defmacro ctimes (x y) `(times ,x ,y))


(meter:meter frpoly
 (meter-funs #.(all-objs)
(defun pcoefadd (e c x) 
       (mn "PCOEFADD" pcoefadd)
       (cond ((pzerop c) x)
	     (t (cons e (cons c x)))))

(defun pcplus (c p) 
 (mn "PCPLUS" pcplus)
 (cond ((pcoefp p) (cplus p c))
       (t (psimp (car p) (pcplus1 c (cdr p))))))

(defun pcplus1 (c x)
 (mn "PCPLUS1" pcplus)
 (cond ((null x)
	(cond ((pzerop c) nil) (t (cons 0 (cons c nil)))))
       ((pzerop (car x)) (pcoefadd 0 (pplus c (cadr x)) nil))
       (t (cons (car x) (cons (cadr x) (pcplus1 c (cddr x)))))))
	 
(defun pctimes (c p)
 (mn "PCTIMES" pctimes)
       (cond ((pcoefp p) (ctimes c p))
	     (t (psimp (car p) (pctimes1 c (cdr p))))))

(defun pctimes1 (c x)
 (mn "PCTIMES1" pctimes1)
       (cond ((null x) nil)
	     (t (pcoefadd (car x)
			  (ptimes c (cadr x))
			  (pctimes1 c (cddr x))))))

(defun pplus (x y) 
       (mn "PPLUS" pplus)
       (cond ((pcoefp x) (pcplus x y))
	     ((pcoefp y) (pcplus y x))
	     ((eq (car x) (car y))
	      (psimp (car x) (pplus1 (cdr y) (cdr x))))
	     ((pointergp (car x) (car y))
	      (psimp (car x) (pcplus1 y (cdr x))))
	     (t (psimp (car y) (pcplus1 x (cdr y))))))

(defun pplus1 (x y)
       (mn "PPLUS1" pplus1)
       (cond ((null x) y)
	     ((null y) x)
	     ((= (car x) (car y))
	      (pcoefadd (car x)
			(pplus (cadr x) (cadr y))
			(pplus1 (cddr x) (cddr y))))
	     ((> (car x) (car y))
	      (cons (car x) (cons (cadr x) (pplus1 (cddr x) y))))
	     (t (cons (car y) (cons (cadr y) (pplus1 x (cddr y)))))))

(defun psimp (var x)
       (mn "PSIMP" psimp)
       (cond ((null x) 0)
	     ((atom x) x)
	     ((zerop (car x)) (cadr x))
	      (t (cons var x))))

(defun ptimes (x y) 
       (mn "PTIMES" ptimes)
       (cond ((or (pzerop x) (pzerop y)) (pzero))
	     ((pcoefp x) (pctimes x y))
	     ((pcoefp y) (pctimes y x))
	     ((eq (car x) (car y))
	      (psimp (car x) (ptimes1 (cdr x) (cdr y))))
	     ((pointergp (car x) (car y))
	      (psimp (car x) (pctimes1 y (cdr x))))
	     (t (psimp (car y) (pctimes1 x (cdr y))))))

(defun ptimes1 (*x* y) 
       (mn "PTIMES1" ptimes1)
       (prog (u* v)
	     (setq v (setq u* (ptimes2 y)))
        a    (setq *x* (cddr *x*))
	     (cond ((null *x*) (return u*)))
	     (ptimes3 y)
	     (go a)))

(defun ptimes2 (y) 
       (mn "PTIMES2" ptimes2)
       (cond ((null y) nil)
	     (t (pcoefadd (plus (car *x*) (car y))
			  (ptimes (cadr *x*) (cadr y))
			  (ptimes2 (cddr y))))))

(defun ptimes3 (y) 
  (mn "PTIMES3" ptimes3)
  (prog (e u c) 
     a1 (cond ((null y) (return nil)))
	(setq e (+ (car *x*) (car y)))
	(setq c (ptimes (cadr y) (cadr *x*) ))
	(cond ((pzerop c) (setq y (cddr y)) (go a1))
	      ((or (null v) (> e (car v)))
	       (setq u* (setq v (pplus1 u* (list e c))))
	       (setq y (cddr y)) (go a1))
	      ((= e (car v))
	       (setq c (pplus c (cadr v)))
	       (cond ((pzerop c) (setq u* (setq v (pdiffer1 u* (list (car v) (cadr v))))))
		     (t (rplaca (cdr v) c)))
	       (setq y (cddr y))
	       (go a1)))
     a  (cond ((and (cddr v) (> (caddr v) e)) (setq v (cddr v)) (go a)))
	(setq u (cdr v))
     b  (cond ((or (null (cdr u)) (< (cadr u) e))
	       (rplacd u (cons e (cons c (cdr u)))) (go e)))
	(cond ((pzerop (setq c (pplus (caddr u) c))) (rplacd u (cdddr u)) (go d))
	      (t (rplaca (cddr u) c)))
     e  (setq u (cddr u))
     d  (setq y (cddr y))
	(cond ((null y) (return nil)))
	(setq e (+ (car *x*) (car y)))
	(setq c (ptimes (cadr y) (cadr *x*)))
     c  (cond ((and (cdr u) (> (cadr u) e)) (setq u (cddr u)) (go c)))
	(go b))) 

(defun pexptsq (p n)
 (mn "PEXPTSQ" pexptsq)
	(do ((n (quotient n 2) (quotient n 2))
	     (s (cond ((oddp n) p) (t 1))))
	    ((zerop n) s)
	    (setq p (ptimes p p))
	    (and (oddp n) (setq s (ptimes s p))) ))



(defun setup nil
  (putprop 'x 1 'order)
  (putprop 'y 2 'order)
  (putprop 'z 3 'order)
  (setq r (pplus '(x 1 1 0 1) (pplus '(y 1 1) '(z 1 1)))) ; r= x+y+z+1
  (setq r2 (ptimes r 100000)) ;r2 = 100000*r
  (setq r3 (ptimes r 1.0)); r3 = r with floating point coefficients
  )))
; time various computations of powers of polynomials, not counting
;printing but including gc time ; provide account of g.c. time.


(defun bench (n)
 (print 'test1)
  (pexptsq r n)   
 (print 'test2)
  (pexptsq r2 n)
 (print 'test3)
  (pexptsq r3 n))